package guru.util.ObjectCall;
import java_cup.runtime.*;
/**
 * Exception thrown by lexical analizer
 */
class TokenNotFoundException extends Throwable {
  public TokenNotFoundException (String msg, int line, int colum)
    {
      super (msg + " Linea: " + line + " Columna: " + colum);
    }  
}
/**
 * Represents the token shifted into the parser
 */
class Yytoken extends Symbol
{
  private String str_value; 
  private Integer int_value;
  private int token_line;
  private int token_column;
  /**
   * Class constructor with a token code
   */
  Yytoken (int code)
    {
      super (code);
    };
  /**
   * Class constructor with a token code, and a string value
   */
  Yytoken (int code, String str_value, int token_line, int token_column) 
    {
      super (code, str_value);
      this.str_value = str_value;
      this.token_line = token_line;
      this.token_column = token_column;
    }
  /**
   * Class constructor with a token code, and a int value
   */
  Yytoken (int code, Integer int_value, int token_line, int token_column) 
    {
      super (code, int_value);
      this.int_value = int_value;
      this.token_line = token_line;
      this.token_column = token_column;
    }
  /**
   * Gets the token code
   * @return token code
   */
  int getCode ()
    {
      return parse_state;
    }
  /**
   * Gets the int value
   * @return int_value (int)
   */
  Integer getIntValue ()
    {
      return int_value;
    }
  /**
   * Gets the str value
   * @return str_value
   */
  String getStrValue ()
    {
      return str_value;
    }
  /**
   * Gets the token line
   * @return token_line
   */
  int getTokenLine ()
    {
      return token_line;
    }
  /**
   * Gets the token column
   * @return token_column
   */
  int getTokenColumn ()
    {
      return token_column;
    }
  /**
   * Sets the token code
   * @param code the new code for this
   */
  void setCode (int code)
    {
      parse_state = code;
    }
  /**
   * Sets the int value
   * @param int_value the new int int_value for this
   */
  void setIntValue (int int_value)
    {
	this.int_value = new Integer (int_value);
    }
  /**
   * Sets the int value
   * @param int_value the new Integer int_value for this
   */
  void setIntValue (Integer int_value)
    {
	this.int_value = int_value;
    }
  /**
   * Sets the str value
   * @param str_value the new str_value for this
   */
  void setStrValue (String str_value)
    {
	this.str_value = str_value;
    }
  /**
   * Sets the token line
   * @param token_line the new token_line for this
   */
  void setTokenLine (int token_line)
    {
        this.token_line = token_line;
    }
  /**
   * Sets the token column
   * @param token_line the new token_line for this
   */
  void setTokenColumn (int token_column)
    {
        this.token_column = token_column;
    }
}


class Yylex {
	private final int YY_BUFFER_SIZE = 512;
	private final int YY_F = -1;
	private final int YY_NO_STATE = -1;
	private final int YY_NOT_ACCEPT = 0;
	private final int YY_START = 1;
	private final int YY_END = 2;
	private final int YY_NO_ANCHOR = 4;
	private final char YYEOF = '\uFFFF';
	private java.io.BufferedReader yy_reader;
	private int yy_buffer_index;
	private int yy_buffer_read;
	private int yy_buffer_start;
	private int yy_buffer_end;
	private char yy_buffer[];
	private int yychar;
	private int yyline;
	private int yy_lexical_state;

	Yylex (java.io.Reader reader) {
		this ();
		if (null == reader) {
			throw (new Error("Error: Bad input stream initializer."));
		}
		yy_reader = new java.io.BufferedReader(reader);
	}

	Yylex (java.io.InputStream instream) {
		this ();
		if (null == instream) {
			throw (new Error("Error: Bad input stream initializer."));
		}
		yy_reader = new java.io.BufferedReader(new java.io.InputStreamReader(instream));
	}

	private Yylex () {
		yy_buffer = new char[YY_BUFFER_SIZE];
		yy_buffer_read = 0;
		yy_buffer_index = 0;
		yy_buffer_start = 0;
		yy_buffer_end = 0;
		yychar = 0;
		yyline = 0;
		yy_lexical_state = YYINITIAL;
	}

	private boolean yy_eof_done = false;
	private final int YYINITIAL = 0;
	private final int yy_state_dtrans[] = {
		0
	};
	private void yybegin (int state) {
		yy_lexical_state = state;
	}
	private char yy_advance ()
		throws java.io.IOException {
		int next_read;
		int i;
		int j;

		if (yy_buffer_index < yy_buffer_read) {
			return yy_buffer[yy_buffer_index++];
		}

		if (0 != yy_buffer_start) {
			i = yy_buffer_start;
			j = 0;
			while (i < yy_buffer_read) {
				yy_buffer[j] = yy_buffer[i];
				++i;
				++j;
			}
			yy_buffer_end = yy_buffer_end - yy_buffer_start;
			yy_buffer_start = 0;
			yy_buffer_read = j;
			yy_buffer_index = j;
			next_read = yy_reader.read(yy_buffer,
					yy_buffer_read,
					yy_buffer.length - yy_buffer_read);
			if (-1 == next_read) {
				return YYEOF;
			}
			yy_buffer_read = yy_buffer_read + next_read;
		}

		while (yy_buffer_index >= yy_buffer_read) {
			if (yy_buffer_index >= yy_buffer.length) {
				yy_buffer = yy_double(yy_buffer);
			}
			next_read = yy_reader.read(yy_buffer,
					yy_buffer_read,
					yy_buffer.length - yy_buffer_read);
			if (-1 == next_read) {
				return YYEOF;
			}
			yy_buffer_read = yy_buffer_read + next_read;
		}
		return yy_buffer[yy_buffer_index++];
	}
	private void yy_move_start () {
		if ((byte) '\n' == yy_buffer[yy_buffer_start]) {
			++yyline;
		}
		++yychar;
		++yy_buffer_start;
	}
	private void yy_pushback () {
		--yy_buffer_end;
	}
	private void yy_mark_start () {
		int i;
		for (i = yy_buffer_start; i < yy_buffer_index; ++i) {
			if ((byte) '\n' == yy_buffer[i]) {
				++yyline;
			}
		}
		yychar = yychar
			+ yy_buffer_index - yy_buffer_start;
		yy_buffer_start = yy_buffer_index;
	}
	private void yy_mark_end () {
		yy_buffer_end = yy_buffer_index;
	}
	private void yy_to_mark () {
		yy_buffer_index = yy_buffer_end;
	}
	private java.lang.String yytext () {
		return (new java.lang.String(yy_buffer,
			yy_buffer_start,
			yy_buffer_end - yy_buffer_start));
	}
	private int yylength () {
		return yy_buffer_end - yy_buffer_start;
	}
	private char[] yy_double (char buf[]) {
		int i;
		char newbuf[];
		newbuf = new char[2*buf.length];
		for (i = 0; i < buf.length; ++i) {
			newbuf[i] = buf[i];
		}
		return newbuf;
	}
	private final int YY_E_INTERNAL = 0;
	private final int YY_E_MATCH = 1;
	private java.lang.String yy_error_string[] = {
		"Error: Internal error.\n",
		"Error: Unmatched input.\n"
	};
	private void yy_error (int code,boolean fatal) {
		java.lang.System.out.print(yy_error_string[code]);
		java.lang.System.out.flush();
		if (fatal) {
			throw new Error("Fatal Error.\n");
		}
	}
private int [][] unpackFromString(int size1, int size2, String st)
    {
      int colonIndex = -1;
      String lengthString;
      int sequenceLength = 0;
      int sequenceInteger = 0;
      int commaIndex;
      String workString;
      int res[][] = new int[size1][size2];
      for (int i= 0; i < size1; i++)
	for (int j= 0; j < size2; j++)
	  {
	    if (sequenceLength == 0) 
	      {	
		commaIndex = st.indexOf(',');
		if (commaIndex == -1)
		  workString = st;
		else
		  workString = st.substring(0, commaIndex);
		st = st.substring(commaIndex+1);
		colonIndex = workString.indexOf(':');
		if (colonIndex == -1)
		  {
		    res[i][j] = Integer.parseInt(workString);
		  }
		else 
		  {
		    lengthString = workString.substring(colonIndex+1);  
		    sequenceLength = Integer.parseInt(lengthString);
		    workString = workString.substring(0,colonIndex);
		    sequenceInteger = Integer.parseInt(workString);
		    res[i][j] = sequenceInteger;
		    sequenceLength--;
		  }
	      }
	    else 
	      {
		res[i][j] = sequenceInteger;
		sequenceLength--;
	      }
	  }
      return res;
    }
	private int yy_acpt[] = {
		YY_NO_ANCHOR,
		YY_NO_ANCHOR,
		YY_NOT_ACCEPT,
		YY_NO_ANCHOR,
		YY_NO_ANCHOR,
		YY_NO_ANCHOR,
		YY_NO_ANCHOR,
		YY_NO_ANCHOR,
		YY_NO_ANCHOR,
		YY_NO_ANCHOR
	};
	private int yy_cmap[] = {
		0, 0, 0, 0, 0, 0, 0, 0,
		0, 1, 1, 0, 1, 1, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0,
		1, 0, 2, 0, 0, 0, 0, 0,
		3, 4, 0, 0, 5, 0, 6, 0,
		7, 7, 7, 7, 7, 7, 7, 7,
		7, 7, 0, 0, 0, 0, 0, 0,
		0, 8, 8, 8, 8, 8, 8, 8,
		8, 8, 8, 8, 8, 8, 8, 8,
		8, 8, 8, 8, 8, 8, 8, 8,
		8, 8, 8, 0, 0, 0, 0, 8,
		0, 8, 8, 8, 8, 8, 8, 8,
		8, 8, 8, 8, 8, 8, 8, 8,
		8, 8, 8, 8, 8, 8, 8, 8,
		8, 8, 8, 0, 0, 0, 0, 0
		
	};
	private int yy_rmap[] = {
		0, 1, 2, 1, 1, 1, 1, 3,
		1, 4 
	};
	private int yy_nxt[][] = unpackFromString(5,9,
"-1,1,2,3,4,5,6,7,9,-1:9,2:2,8,2:6,-1:7,7,9,-1:7,9:2");
	public Yytoken yylex ()
		throws java.io.IOException, 
  TokenNotFoundException

		{
		char yy_lookahead;
		int yy_anchor = YY_NO_ANCHOR;
		int yy_state = yy_state_dtrans[yy_lexical_state];
		int yy_next_state = YY_NO_STATE;
		int yy_last_accept_state = YY_NO_STATE;
		boolean yy_initial = true;
		int yy_this_accept;

		yy_mark_start();
		yy_this_accept = yy_acpt[yy_state];
		if (YY_NOT_ACCEPT != yy_this_accept) {
			yy_last_accept_state = yy_state;
			yy_mark_end();
		}
		while (true) {
			yy_lookahead = yy_advance();
			yy_next_state = YY_F;
			if (YYEOF != yy_lookahead) {
				yy_next_state = yy_nxt[yy_rmap[yy_state]][yy_cmap[yy_lookahead]];
			}
			if (YY_F != yy_next_state) {
				yy_state = yy_next_state;
				yy_initial = false;
				yy_this_accept = yy_acpt[yy_state];
				if (YY_NOT_ACCEPT != yy_this_accept) {
					yy_last_accept_state = yy_state;
					yy_mark_end();
				}
			}
			else {
				if (YYEOF == yy_lookahead && true == yy_initial) {

  return (new Yytoken (sym.EOF));
				}
				else if (YY_NO_STATE == yy_last_accept_state) {
					throw (new Error("Lexical Error: Unmatched Input."));
				}
				else {
					yy_to_mark();
					yy_anchor = yy_acpt[yy_last_accept_state];
					if (0 != (YY_END & yy_anchor)) {
						yy_pushback();
					}
					if (0 != (YY_START & yy_anchor)) {
						yy_move_start();
					}
					switch (yy_last_accept_state) {
					case 0:
						{return new Yytoken (sym.ID,yytext(),yyline + 1,yychar + 1);}
					case -2:
						break;
					case 1:
						{}
					case -3:
						break;
					case 3:
						{return new Yytoken (sym.OPEN,yytext(),yyline + 1,yychar + 1);}
					case -4:
						break;
					case 4:
						{return new Yytoken (sym.CLOSE,yytext(),yyline + 1,yychar + 1);}
					case -5:
						break;
					case 5:
						{return new Yytoken (sym.COMMA,yytext(),yyline + 1,yychar + 1);}
					case -6:
						break;
					case 6:
						{return new Yytoken (sym.DOT,yytext(),yyline + 1,yychar + 1);}
					case -7:
						break;
					case 7:
						{return new Yytoken (sym.INTEGER,yytext(),yyline + 1,yychar + 1);}
					case -8:
						break;
					case 8:
						{return new Yytoken (sym.STRING,yytext(),yyline + 1,yychar + 1);}
					case -9:
						break;
					case 9:
						{return new Yytoken (sym.ID,yytext(),yyline + 1,yychar + 1);}
					case -10:
						break;
					default:
						yy_error(YY_E_INTERNAL,false);
					case -1:
					}
					yy_initial = true;
					yy_state = yy_state_dtrans[yy_lexical_state];
					yy_next_state = YY_NO_STATE;
					yy_last_accept_state = YY_NO_STATE;
					yy_mark_start();
					yy_this_accept = yy_acpt[yy_state];
					if (YY_NOT_ACCEPT != yy_this_accept) {
						yy_last_accept_state = yy_state;
					}
				}
			}
		}
	}
}
